package com.wang.fuxi;

import java.io.IOException;
import java.util.Arrays;

public class Test {
	static int count = 0;

	public static void main(String[] args) throws IOException {
		/****************************包装类以Integer为例***********************************/
		/*
		 *	构造方法： 
		  		1.Integer(int value) 构造一个新分配的 Integer对象，该对象表示指定的 int值。  
				2.Integer(String s) 构造一个新分配 Integer对象，表示 int由指示值 String参数。  
		 */
		Integer integer = new Integer(128); //128		
		//Integer integer2 = new Integer("2a");//NumberFormatException数字格式异常，通常是将字符串转换为数值类型的时候，有非数字的字符的时候发生该错误
		Integer integer2 = new Integer("2");//2
		//调用普通方法：1. static修饰的 =>类名.方法名(....)	2. 非static修饰的	=>对象名.方法名(....)
		//1. byte byteValue() 返回此值 Integer为 byte的基本收缩转换后。  如果超出表示范围，会强制转换
		byte byteValue = integer.byteValue();//-128   转换的时候，如果超过byte表示范围，会以二进制方式进位
		//2. static int max(int a, int b) 返回两个 int的较大值，就像调用 Math.max一样 。  
		//3. static int min(int a, int b) 返回两个 int的较小值，就像调用 Math.min一样 。  
		int max = Integer.max(1,5);//5		
		//4. static int parseInt(String s) 将字符串参数解析为带符号的十进制整数。  
		int parseInt = Integer.parseInt("-3");//-3		
		//5. static int sum(int a, int b) 根据+运算符将两个整数相加。 
		int sum = Integer.sum(1,2);//3
		//6. static String toHexString(int i) 将int类型的十进制值转换为十六进制的值 
		String hexString = Integer.toHexString(15);//f		
		//7. static Integer valueOf(String s)  将String类型转换为Integer类型
		Integer valueOf = Integer.valueOf("1");//1
		/****************************享元模式***********************************/
		/**
		 *	自动装箱：将基本类型转换为其对应的包装类。
		 *	自动拆箱：将包装类转换为基本类型。注意：这里可以是高于int的任何类型
		 *	享元模式：
		 *			Byte、Short、Integer、Long类型当创建对象的时候，范围在 -128~127之间的时候，并不会在堆中创建对象
		 *	而是直接从静态区中获取缓存的对象，所以，所有在此范围内的相同类型的包装类对象地址都是相同的。
		 */
		Integer integer21 = new Integer(1);//不是自动装箱
		Integer integer1 = 1222;//自动装箱，将基本类型转换为其对应的包装类。		
		long i = integer;//自动拆箱，将包装类转换为基本类型。注意：这里可以是高于int的任何类型		
		Integer integer3 = new Integer(127);
		Integer integer4 = new Integer(127);
		//如果 Integer integer3 = 127   Integer integer4 = 127 则 integer3 == integer4 true  享元模式
		System.out.println(integer3 == integer4);//比较两个是不是同一个对象，即地址是不是一样	false
		System.out.println(integer3.equals(integer4));//比较两个对象的值是不是一样  true
		/**
		 * System类常用方法：
		 * 		1.System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)(掌握)数组复制方法
		 *			src: 源数组
		 *			srcPos:源数组开始复制的下标
		 *			dest: 目标数组
		 *			destPos:目标数组开始复制下标
		 *			length: 复制的元素个数
		 *			从源数组src中的srcPos下标处，开始复制 length个元素到目标数组dest中，从destPos下标开始粘贴
				2.System.currentTimeMillis()（掌握）返回当前时间毫秒数。主要是用了测试程序运行时间
				
				==================下面作为了解=============================
				3. System.exit(int status)结束当前JVM		status - 退出状态。 非0状态码表示异常终止
				4. System.gc() 调用垃圾（堆中匿名对象）回收器		stop all the world  所有代码执行都会停止，等待垃圾收完后，才继续执行
		 */
		//调用System字段: 今天不用
		System.out.println(System.in);
		System.out.println(System.out);
		System.out.println(System.err);
		int[] src = {1,2,3,4,4,5,8,6,6,6};int[] dest = new int[6];
		System.arraycopy(src, 2, dest,1, 3);// src [1, 2, 3, 4, 4, 5, 8, 6, 6, 6] dest [0, 3, 4, 4, 0, 0]
		int[] copyOf = Arrays.copyOf(src,12);//12大于src的length，所以是扩容  copyOf [1, 2, 3, 4, 4, 5, 8, 6, 6, 6, 0, 0] src [1, 2, 3, 4, 4, 5, 8, 6, 6, 6]
		int[] copyOf2 = Arrays.copyOf(src,6);//6小于src的length，所以是缩容  copyOf [1, 2, 3, 4, 4, 5]  src [1, 2, 3, 4, 4, 5, 8, 6, 6, 6]
		//测试System.exit(int status)方法
		//System.exit(0);
		/*
		  for (int i = 0; i < 100000; i++) {new Garbage();}
		  System.gc();
		  class Garbage{
				static int count = 0;
				@Override//在对象被回收的时候，会自动调用
				protected void finalize() throws Throwable {
					System.err.println("被收了" + ++count);
				}}*//**
		 *	Runtime类：该类可以通过Java代码执行启动一个进程（一个应用程序）
		 *		使用方式：	
		 *			1. 获取对象，类似单例模式	
		 *			Runtime runtime = Runtime.getRuntime();
		 *			2.Process exec(String command) 通过字符串参数，启动对应名字的进程，并且返回该进程
		 *		注意：只能执行启动该文件夹 c:\windows\system32下
		 */
		//1. 获取对象，类似单例模式	
		Runtime runtime = Runtime.getRuntime();
		//2.Process exec(String command) 通过字符串参数，启动对应名字的进程，并且返回该进程
		runtime.exec("notepad.exe");
		runtime.exec("mspaint.exe");
		runtime.exec("FeiQ.exe");//只能执行启动该文件夹 c:\windows\system32下
		/**
		 *	字符串相关的类：
		 *		1. String 字符串类，底层是基于char[], 一旦创建长度就固定不变了,适用于字符串不经常增删改的操作的场景。父接口：CharSequence
		 *			该接口的实现类：String、StringBuffer、StringBuilder
		 *		String str = "abc";
		 *		str += "d";//会创建新对象
		 *		2. 将其他类型转换为String类型的方式效率问题：
		 *			toString() > String.valueOf(Object obj); > +
		 *			因为+号，底层先将字符串对象转换为StringBuilder对象，然后调用StringBuilder对象的append追加字符串方法，再调用toString方法
		 *			转换为String对象
		 *		3. 拼接字符串效率最高的方式：
		 * 			StringBuilder.append() > StringBuffer.append() > +
		 *			如果经常操作字符串用StringBuilder和StringBuffer，如果是单线程或者多线程且不要求线程安全问题，用StringBuilder，
		 * 			如果是多线程且是线程安全要求用StringBuffer
		 *	注意：
		 *		常用字符集有：
		 *			UTF-8（世界通用编码集）变长字符（占用字节：1-3个），GBK（中国）（英文数字1个，中文2个字节）
		 *
		 *	
		 *  Interface CharSequence 的抽象方法(常用的)
		 *	char          charAt(int index) 返回 char指定索引处的值。  
			int           length() 返回此字符序列的长度。  
			CharSequence  subSequence(int start, int end) 返回一个 CharSequence ，这是这个序列的一个子序列。  
			String        toString() 以与此顺序相同的顺序返回包含此序列中的字符的字符串。  
		 *
		 *
		 */
		/*
		 * 构造方法：
		 * 		1-4在IO流很常用
				1. String(byte[] bytes, String charsetName) 解码，将字节转换为字符串的过程
						将byte数组，使用指定字符集转换为 String对象。   
				2. String(byte[] bytes) 将byte数组，用默认字符集转换为 String对象。  
				3. String(byte[] bytes, int offset, int length) 
						将byte数组的指定下标开始，指定长度的数据，使用默认字符集转换为 String对象。    
				4. String(byte[] bytes, int offset, int length, String charsetName) charsetName：字符集名
						将byte数组的指定下标开始，指定长度的数据，使用指定字符集转换为 String对象。 
		 		5. String() 创建一个空的 String对象
				6. String(char[] value) 
						将char数组转换为 String对象。   
				7. String(char[] value, int offset, int count) 
						将char数组的指定下标开始，指定长度的数据，转换为 String对象。 
				8.String(String original) 创建一个包含指定的String数据的String对象
						new String("abc");
				9.String(StringBuffer buffer) 
						将StringBuffer转为参数转换为String对象
				10.String(StringBuilder builder) 
						将StringBuilder转为参数转换为String对象
		 */
		String str = new String("");//无参构造创建
		String str2 = "";//常量创建
		System.out.println(str2.equals(str));//true
		str = "富民速八.avi;波波老师和富民的故事.avi";
		System.out.println(str);
		char[] c = {'a','b','c','d'};
		System.out.println(Arrays.toString(c));//[a, b, c, d]
		System.out.println(c);//abcd,这里直接打印字符串
		//常用方法：
		//1.char charAt(int index) 返回 char指定索引处的值。 
		str = "abcdefg";
		char charAt = str.charAt(0);//a
		//2.String concat(String str) 将指定的字符串连接到该字符串的末尾。 相当于：+
		String concat = str.concat("土豪的日子我们不懂");
		System.out.println("原来的字符串不变：" + str);//原来的字符串不变：abcdefg
		System.out.println("拼接后的字符串："+concat);//拼接后的字符串：abcdefg土豪的日子我们不懂
		//3.boolean contains(CharSequence s) 判断当前对象是否包含连续的CharSequence（String、StringBuffer、StringBuilder）串
		boolean contains = str.contains("abc");//判断当前对象str是否包含连续的参数abc
		System.out.println(contains);//true
		//4.boolean endsWith(String suffix) 判断当前字符串是否以指定的后缀suffix结尾。  
		//5.boolean startsWith(String prefix) 判断当前字符串是否以指定的前缀prefix开头。  
		str = "富民速八.avi";
		boolean endsWith = str.endsWith(".avi");//true
		boolean startWith = str.startsWith(".avi");//false
		//6.byte[] getBytes()  编码：将字符串对象按照默认字符集转换为字节数组
		//7.byte[] getBytes(String charsetName)   编码：将字符串对象按照指定字符集转换为字节数组
		byte[] bytes = str.getBytes();
		System.out.println(Arrays.toString(bytes));//[-27, -81, -116, -26, -80, -111, -23, -128, -97, -27, -123, -85, 46, 97, 118, 105]
		//8.void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将此字符串中的字符复制到目标字符数组中。  (含头不含尾)[srcBegin,srcEnd)
		str = "abcdabefg";
		char[] dst = new char[10];
		str.getChars(1,7,dst, 2);
		System.out.println(dst);//  bcdabe  注意前后都有两个空格
		//9.int indexOf(String s) 返回s第一次在当前对象str中出现的索引 ，-1表示没有找到（注意：这里s必须也是匹配连续的字符串）
		int indexOf = str.indexOf("ab");//0
		//10.int indexOf(String s, int fromIndex) 返回s在当前对象指定下标fromIndex后第一次出现的索引  (str是作为一个整体匹配下标的)
		int indexOf2 = str.indexOf("ab",3);//4
		//11.int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引。  
		//12.int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向前搜索。  
		str = "abcdabefg";
		int lastIndexOf = str.lastIndexOf("ab",4);//4 刚好和formIndex相等也返回指定索引
		//13.boolean isEmpty() 当 length()为 0时，返回 true 。  
		str = "";
		boolean empty = str.isEmpty();
		System.out.println("是否为空：" + empty);//是否为空：true
		//14.int length() 返回此字符串的长度。  
		int length = str.length();//0
		//15.boolean matches(String regex)  判断当前字符串对象是否匹配给定的正则表达式regex，通常用来进行权限限制，字符格式限制   	一般用了做校验：如，用户名和密码的合法性
		str = "abcdAB";
		String regex = "[a-zA-Z]+";//匹配a-z或者A-Z之间任意多个字符
		boolean matches = str.matches(regex);//true		
		//16.String replace(CharSequence target, CharSequence replacement)   将当前字符串中的target替换为replacement,通常用来和谐用语
		str = "你是DSB，就是个DSB";//WQNMLGB/DSB/CNM：和谐用语
		String replace = str.replace(new StringBuilder("DSB"), "***");//注意参数类型和多态应用
		System.out.println(replace);//你是***，就是个***
		System.out.println(str);//你是DSB，就是个DSB
		//17.String replaceAll(String regex, String replacement) regex是正则表达式，将当前字符串中的regex全部替换为replacement  
		str = "你是DSB，就是个DSB";
		regex = "DSB";
		String replaceAll = str.replaceAll(regex, "***");
		System.out.println(replaceAll);//你是***，就是个***
		//18.String replaceFirst(String regex, String replacement)  将当前字符串中的第一个regex替换为replacement 
		String replaceAll1 = str.replaceFirst(regex, "***");
		System.out.println(replaceAll1);//你是***，就是个DSB
		/**
		 * replace()和replaceAll()，replaceFirst()区别
		 * replace()只能匹配String、StringBuffer、StringBuilder对象
		 * replaceAll()和replaceFirst()可以匹配正则表达式，更灵活
		 */
		str = "富民速八.avi";
		String replace2 = str.replace(".","#");
		System.out.println("replace:" + replace2);//replace:富民速八#avi
		String replaceAll2 = str.replaceAll(".","#");//在正则表达式中,.表示匹配任意一个字符
		System.out.println("replaceAll:" + replaceAll2);//replaceAll:########
		//19.String[] split(String regex)  将当前字符串对象按照给定的正则表达式regex分割为String[]
		str = "bobo如家.avi;富民优衣库高清版.mp4;鹰鹰Xxx热.avi;如何让富婆3天之内爱上你手册.doc;";
		//请将字符串中所有的AVI文件打印出来
		String[] split = str.split("\\.");//注意这个需要两次转义 有疑问跟踪代码
		System.out.println(Arrays.toString(split));//[bobo如家, avi;富民优衣库高清版, mp4;鹰鹰Xxx热, avi;如何让富婆3天之内爱上你手册, doc;]
		//20.CharSequence subSequence(int beginIndex, int endIndex)  从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）
		str = "abcdefg";
		CharSequence subSequence = str.subSequence(2,5);
		System.out.println(new StringBuilder(subSequence));//cde 注意返回值类型
		//21.String substring(int beginIndex)   从当前字符串中截取beginIndex到最后的子串
		//22.String substring(int beginIndex, int endIndex)  从当前字符串中beginIndex和endIndex之间截取子串（含头不含尾）
		//23.char[] toCharArray() 将此字符串转换为新的字符数组。  方便遍历当前所有的字符
		char[] charArray = str.toCharArray();
		System.out.println(Arrays.toString(charArray));//[a, b, c, d, e, f, g]
		//24.String toUpperCase() 将此字符转换为全大写	一般用于验证码
		System.out.println("abc".toUpperCase());//ABC
		//25.String toLowerCase() 将此字符转换为全小写	一般用于验证码
		System.out.println("ABC".toLowerCase());//abc
		//26.String trim() 将当前字符串对象中字符前面和后面的空格去除	用了避免用户的一些不当输入
		str = "		abc	asdfa			sda				";
		String trim = str.trim();
		System.out.println(trim);//abc	asdfa			sda
		//27.static String valueOf(Object obj) 将其他类型转换为String对象
		String valueOf1 = String.valueOf(1);//这里其实是1的包装类Integer
		System.out.println(valueOf1);//1
		/**
		 *  String 字符串类，底层是基于char[], 一旦创建长度就固定不变了,适用于字符串不经常增删改的操作的场景。
		 *	StringBuilder: 基于定长的char[]，默认长度是16个，适用于频繁操作（增删改插）字符串的场景，该类是线程不安全的。
		 *	StringBuffer:基于定长的char[]，默认长度是16个，适用于频繁操作（增删改插）字符串的场景，该类是线程安全的。
		 *  StringBuilder.append() > StringBuffer.append() > + 
		 *	因为StringBuilder和StringBuffer拼接字符串效率高，所以，以后拼接字符串较大用这两个类，不拼接用String
		 *	因为StringBuilder效率更高，如果是单线程和多线程没有线程安全要求，用StringBuilder
		 *	如果是多线程有线程安全要求，用StringBuffer
		 */
		/*
		 * 构造方法：
		 * 		1.StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。  
				2.StringBuilder(CharSequence seq) 构造一个包含与指定的相同字符的字符串构建器 CharSequence 。  
				3.StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。  	节省了数组扩容时间
				4.StringBuilder(String str)构造一个初始化为指定字符串内容的字符串构建器。  
		 *
		 */
		StringBuilder sb = new StringBuilder();//创建一个默认16个长度的char[]数组
		StringBuilder sb2 = new StringBuilder("abc");//创建一个19个长度的char[]数组
		/*
		 * 常用方法：
		 * 		1. StringBuilder append(Object obj) 在队尾添加字符串   
		 * 		2. StringBuilder delete(int start, int end)  删除指定起始和结束位置之间的字符（含头不含尾）
		 * 		3. StringBuilder deleteCharAt(int index) 删除指定下标处的字符
		 * 		4. StringBuilder insert(int offset, Object obj) 在指定下标处插入一个任意类型数据
		 * 		5. StringBuilder reverse()将字符串翻转
		 * 		6. void          setCharAt(int index, char ch) 修改指定下标处的字符为ch  
				7. void          setLength(int newLength)  设置字符串长度是newLength
   				8. void          trimToSize() 将所有没有使用的数组空间去除	。 如果使用setLength,该方法无效
		 * 		9. int           capacity() 返回当前容量。  
		 */
		
		//append方法
		sb.append(true).append("abc");
		System.out.println(sb);//trueabc
		//delete方法
		sb.delete(0, 3);//含头不含尾
		System.out.println(sb);//eabc
		//3. StringBuilder deleteCharAt(int index) 删除指定下标处的字符
		sb.deleteCharAt(0);
		System.out.println(sb);//eabc
		//insert
		sb.insert(0,true).insert(0,"狼牙棒").insert(0, new Object());
		System.out.println(sb);//java.lang.Object@4e25154f狼牙棒trueabc
		//reverse()
		sb.reverse();
		System.out.println(sb);//cbaeurt棒牙狼f45152e4@tcejbO.gnal.avaj
		//setCharAt()
		sb.setCharAt(0, '插');
		System.out.println(sb);//插baeurt棒牙狼f45152e4@tcejbO.gnal.avaj
		//setLength()
		//sb.setLength(1000);
		System.out.println(sb.length());
		System.out.println(sb);//35
		//int capacity() 返回当前容量。  
		int capacity = sb.capacity();
		System.out.println(capacity);//35
		//trimToSize() 如果使用setLength,该方法无效
		StringBuilder sb3 = new StringBuilder("abc");//长度是19  
		int capacity3 = sb3.capacity();
		System.out.println(capacity3);//19
		sb3.trimToSize();
		int capacity4 = sb3.capacity();
		System.out.println(capacity4);//3
		System.out.println(sb3);//abc
		
		
		
		
		
		
		
	}
	

}
